fix(streaming): close the SSE event iterators a stream opens - #1

- Keep the Iterator/AsyncIterator contracts so existing __stream__
  overrides stay valid; close owned iterators through close_owned /
  aclose_owned, which skip objects without close()/aclose().
- Do not let a cleanup error replace the error or cancellation already
  propagating, and shield async cleanup from caller cancellation.
- Create the byte and decoder iterators inside the exception-translation
  block, and loop explicitly in the sync stream so the decoder iterator
  is closed once.
- close() closes the response even when iterator cleanup fails.
- Chat and Responses stream wrappers close their own iterator and the raw
  stream instead of only the response; agent streams close the parent
  stream iterator they consume.
- Tests cover the byte iterator, the chat wrapper, single close of custom
  decoder iterators, and error precedence.

- GeneratorExit from close() or [DONE] is normal closure; it no longer
  counts as a primary failure that silences cleanup errors.
- close_owned/aclose_owned look up and call each closer inside the same
  handler, attempt every resource even after a BaseException, and never
  drop a cancellation raised during cleanup in favor of an ordinary
  error.
- The response joins the same cleanup call as the iterators, so it is
  shielded and follows the same error precedence.
- Comments no longer claim that closing the response ends a concurrent
  consumer.
- Tests check [DONE] cleanup without an explicit close(), cleanup errors
  surfacing on normal closure, and aclose_owned continuing after
  cancellation.

…p errors

- Cleanup helpers let a later control-flow exception (for example
  cancellation) replace an earlier ordinary cleanup failure.
- Agent streams pass the propagating error into cleanup in
  get_final_result(), the event iterator and failed entry, so a decoder
  close failure no longer replaces AgentTurnResultError.
- run_cleanup() covers owners whose async close method is not aclose().
- Tests cover cancellation after an ordinary cleanup error and a failed
  agent turn whose decoder close also fails.

AgentSessionStream closes its connection when it sees the terminal event,
before yielding it. A cleanup failure there was raised before the caller
evaluated the outcome, turning a failed turn or an output parse error
into observation_failed. The failure is now kept and raised only after
the outcome is established (or on the next read when iterating by hand);
a result error still wins.

close() also closes the stream's own iterator when it is not running.

The terminal close marks the stream closed, so the next read stopped
before reaching the deferred cleanup failure and ordinary iteration,
until_done() and close-after-terminal all hid it. Reads on a closed
stream and close() now raise the pending failure once. A result error
from get_final_result() or an exception leaving the with block still
takes precedence and discards it.

…errors

Context-manager exits closed streams without passing the exception that
was leaving the block, so a cleanup failure could replace the caller's
exception or a task cancellation. Stream, AsyncStream, the Chat and
Responses streams and their managers, and the agent session streams now
pass it as the primary failure.